using Baci.Net.ToolKit.ArcGISProGeoprocessor.Models;
using Baci.Net.ToolKit.ArcGISProGeoprocessor.Models.Attributes;
using Baci.Net.ToolKit.ArcGISProGeoprocessor.Models.Attributes.DomainAttributes;
using Baci.Net.ToolKit.ArcGISProGeoprocessor.Models.Enums;
using System.Collections.Generic;
using System.ComponentModel;

namespace Baci.ArcGIS._ImageAnalystTools._MultidimensionalAnalysis
{
    /// <summary>
    /// <para>Aggregate Multidimensional Raster</para>
    /// <para>Generates a multidimensional raster dataset by combining existing multidimensional raster variables along a dimension.</para>
    /// <para>通过沿维度组合现有的多维栅格变量来生成多维栅格数据集。</para>
    /// </summary>    
    [DisplayName("Aggregate Multidimensional Raster")]
    public class AggregateMultidimensionalRaster : AbstractGPProcess
    {
        /// <summary>
        /// 无参构造
        /// </summary>
        public AggregateMultidimensionalRaster()
        {

        }

        /// <summary>
        /// 有参构造
        /// </summary>
        /// <param name="_in_multidimensional_raster">
        /// <para>Input Multidimensional Raster</para>
        /// <para>The input multidimensional raster dataset.</para>
        /// <para>输入多维栅格数据集。</para>
        /// </param>
        /// <param name="_dimension">
        /// <para>Dimension</para>
        /// <para>The aggregation dimension. This is the dimension along which the variables will be aggregated.</para>
        /// <para>聚合维度。这是聚合变量的维度。</para>
        /// </param>
        /// <param name="_out_multidimensional_raster">
        /// <para>Output Multidimensional Raster</para>
        /// <para>The output Cloud Raster Format (CRF) multidimensional raster dataset.</para>
        /// <para>输出云栅格格式 （CRF） 多维栅格数据集。</para>
        /// </param>
        public AggregateMultidimensionalRaster(object _in_multidimensional_raster, object _dimension, object _out_multidimensional_raster)
        {
            this._in_multidimensional_raster = _in_multidimensional_raster;
            this._dimension = _dimension;
            this._out_multidimensional_raster = _out_multidimensional_raster;
        }
        public override string ToolboxName => "Image Analyst Tools";

        public override string ToolName => "Aggregate Multidimensional Raster";

        public override string CallName => "ia.AggregateMultidimensionalRaster";

        public override List<string> AcceptEnvironments => ["cellSize", "compression", "configKeyword", "extent", "geographicTransformations", "nodata", "outputCoordinateSystem", "parallelProcessingFactor", "pyramid", "rasterStatistics", "resamplingMethod", "scratchWorkspace", "snapRaster", "tileSize", "workspace"];

        public override object[] ParameterInfo => [_in_multidimensional_raster, _dimension, _out_multidimensional_raster, _aggregation_method.GetGPValue(), _variables, _aggregation_def.GetGPValue(), _interval_keyword.GetGPValue(), _interval_value, _interval_unit.GetGPValue(), _interval_ranges, _aggregation_function, _ignore_nodata.GetGPValue(), _dimensionless.GetGPValue(), _percentile_value, _percentile_interpolation_type.GetGPValue()];

        /// <summary>
        /// <para>Input Multidimensional Raster</para>
        /// <para>The input multidimensional raster dataset.</para>
        /// <para>输入多维栅格数据集。</para>
        /// <para></para>
        /// </summary>
        [DisplayName("Input Multidimensional Raster")]
        [Description("")]
        [Option(OptionTypeEnum.Must)]
        public object _in_multidimensional_raster { get; set; }


        /// <summary>
        /// <para>Dimension</para>
        /// <para>The aggregation dimension. This is the dimension along which the variables will be aggregated.</para>
        /// <para>聚合维度。这是聚合变量的维度。</para>
        /// <para></para>
        /// </summary>
        [DisplayName("Dimension")]
        [Description("")]
        [Option(OptionTypeEnum.Must)]
        public object _dimension { get; set; }


        /// <summary>
        /// <para>Output Multidimensional Raster</para>
        /// <para>The output Cloud Raster Format (CRF) multidimensional raster dataset.</para>
        /// <para>输出云栅格格式 （CRF） 多维栅格数据集。</para>
        /// <para></para>
        /// </summary>
        [DisplayName("Output Multidimensional Raster")]
        [Description("")]
        [Option(OptionTypeEnum.Must)]
        public object _out_multidimensional_raster { get; set; }


        /// <summary>
        /// <para>Aggregation Method</para>
        /// <para><xdoc>
        ///   <para>Specifies the mathematical method that will be used to combine the aggregated slices in an interval.</para>
        ///   <bulletList>
        ///     <bullet_item>Mean—The mean of a pixel's values will be calculated across all slices in the interval. This is the default.</bullet_item><para/>
        ///     <bullet_item>Maximum—The maximum value of a pixel will be calculated across all slices in the interval.</bullet_item><para/>
        ///     <bullet_item>Majority—The pixel value that occurred most frequently will be calculated across all slices in the interval.</bullet_item><para/>
        ///     <bullet_item>Minimum—The minimum value of a pixel will be calculated across all slices in the interval.</bullet_item><para/>
        ///     <bullet_item>Minority—The pixel value that occurred least frequently will be calculated across all slices in the interval.</bullet_item><para/>
        ///     <bullet_item>Median—The median value of a pixel will be calculated across all slices in the interval.</bullet_item><para/>
        ///     <bullet_item>Percentile—The percentile of values for a pixel will be calculated across all slices in the interval. The 90th percentile is calculated by default. You can specify other values (from 0 to 100) using the Percentile value parameter.</bullet_item><para/>
        ///     <bullet_item>Range—The range of values for a pixel will be calculated across all slices in the interval.</bullet_item><para/>
        ///     <bullet_item>Standard Deviation—The standard deviation of a pixel's values will be calculated across all slices in the interval.</bullet_item><para/>
        ///     <bullet_item>Sum—The sum of a pixel's values will be calculated across all slices in the interval.</bullet_item><para/>
        ///     <bullet_item>Variety—The number of unique pixel values will be calculated across all slices in the interval.</bullet_item><para/>
        ///     <bullet_item>Custom—The pixel value will be calculated based on a custom raster function.</bullet_item><para/>
        ///   </bulletList>
        ///   <para>When the method is set to Custom, the Aggregation Function parameter becomes active.</para>
        /// </xdoc></para>
        /// <para><xdoc>
        ///   <para>指定将用于在间隔中合并聚合切片的数学方法。</para>
        ///   <bulletList>
        ///     <bullet_item>均值—将计算区间内所有剖面的像素值的平均值。这是默认设置。</bullet_item><para/>
        ///     <bullet_item>最大值—将在间隔内的所有切片中计算像素的最大值。</bullet_item><para/>
        ///     <bullet_item>多数 - 将计算间隔内所有切片中出现频率最高的像素值。</bullet_item><para/>
        ///     <bullet_item>最小值—将在间隔内的所有切片中计算像素的最小值。</bullet_item><para/>
        ///     <bullet_item>少数 - 将计算间隔内所有切片中出现频率最低的像素值。</bullet_item><para/>
        ///     <bullet_item>中位数—将计算间隔内所有剖面的像素的中值。</bullet_item><para/>
        ///     <bullet_item>百分位数—将在间隔内的所有剖面上计算像素值的百分位数。默认情况下计算第 90 个百分位数。您可以使用百分位数值参数指定其他值（从 0 到 100）。</bullet_item><para/>
        ///     <bullet_item>范围—将计算间隔内所有切片的像素值范围。</bullet_item><para/>
        ///     <bullet_item>标准差—将计算像素值的标准差，以计算间隔内所有切片的标准差。</bullet_item><para/>
        ///     <bullet_item>总和—将计算间隔内所有剖面的像素值总和。</bullet_item><para/>
        ///     <bullet_item>多样性—将计算间隔内所有切片的唯一像素值数。</bullet_item><para/>
        ///     <bullet_item>自定义 - 像素值将基于自定义栅格函数进行计算。</bullet_item><para/>
        ///   </bulletList>
        ///   <para>当该方法设置为 Custom 时，Aggregation Function 参数将变为活动状态。</para>
        /// </xdoc></para>
        /// <para></para>
        /// </summary>
        [DisplayName("Aggregation Method")]
        [Description("")]
        [Option(OptionTypeEnum.optional)]
        public _aggregation_method_value _aggregation_method { get; set; } = _aggregation_method_value._MEAN;

        public enum _aggregation_method_value
        {
            /// <summary>
            /// <para>Mean</para>
            /// <para>Mean—The mean of a pixel's values will be calculated across all slices in the interval. This is the default.</para>
            /// <para>均值—将计算区间内所有剖面的像素值的平均值。这是默认设置。</para>
            /// </summary>
            [Description("Mean")]
            [GPEnumValue("MEAN")]
            _MEAN,

            /// <summary>
            /// <para>Minimum</para>
            /// <para>Minimum—The minimum value of a pixel will be calculated across all slices in the interval.</para>
            /// <para>最小值—将在间隔内的所有切片中计算像素的最小值。</para>
            /// </summary>
            [Description("Minimum")]
            [GPEnumValue("MINIMUM")]
            _MINIMUM,

            /// <summary>
            /// <para>Maximum</para>
            /// <para>Maximum—The maximum value of a pixel will be calculated across all slices in the interval.</para>
            /// <para>最大值—将在间隔内的所有切片中计算像素的最大值。</para>
            /// </summary>
            [Description("Maximum")]
            [GPEnumValue("MAXIMUM")]
            _MAXIMUM,

            /// <summary>
            /// <para>Minority</para>
            /// <para>Minority—The pixel value that occurred least frequently will be calculated across all slices in the interval.</para>
            /// <para>少数 - 将计算间隔内所有切片中出现频率最低的像素值。</para>
            /// </summary>
            [Description("Minority")]
            [GPEnumValue("MINORITY")]
            _MINORITY,

            /// <summary>
            /// <para>Majority</para>
            /// <para>Majority—The pixel value that occurred most frequently will be calculated across all slices in the interval.</para>
            /// <para>多数 - 将计算间隔内所有切片中出现频率最高的像素值。</para>
            /// </summary>
            [Description("Majority")]
            [GPEnumValue("MAJORITY")]
            _MAJORITY,

            /// <summary>
            /// <para>Median</para>
            /// <para>Median—The median value of a pixel will be calculated across all slices in the interval.</para>
            /// <para>中位数—将计算间隔内所有剖面的像素的中值。</para>
            /// </summary>
            [Description("Median")]
            [GPEnumValue("MEDIAN")]
            _MEDIAN,

            /// <summary>
            /// <para>Range</para>
            /// <para>Range—The range of values for a pixel will be calculated across all slices in the interval.</para>
            /// <para>范围—将计算间隔内所有切片的像素值范围。</para>
            /// </summary>
            [Description("Range")]
            [GPEnumValue("RANGE")]
            _RANGE,

            /// <summary>
            /// <para>Standard Deviation</para>
            /// <para>Standard Deviation—The standard deviation of a pixel's values will be calculated across all slices in the interval.</para>
            /// <para>标准差—将计算像素值的标准差，以计算间隔内所有切片的标准差。</para>
            /// </summary>
            [Description("Standard Deviation")]
            [GPEnumValue("STD")]
            _STD,

            /// <summary>
            /// <para>Sum</para>
            /// <para>Sum—The sum of a pixel's values will be calculated across all slices in the interval.</para>
            /// <para>总和—将计算间隔内所有剖面的像素值总和。</para>
            /// </summary>
            [Description("Sum")]
            [GPEnumValue("SUM")]
            _SUM,

            /// <summary>
            /// <para>Variety</para>
            /// <para>Variety—The number of unique pixel values will be calculated across all slices in the interval.</para>
            /// <para>多样性—将计算间隔内所有切片的唯一像素值数。</para>
            /// </summary>
            [Description("Variety")]
            [GPEnumValue("VARIETY")]
            _VARIETY,

            /// <summary>
            /// <para>Percentile</para>
            /// <para>Percentile—The percentile of values for a pixel will be calculated across all slices in the interval. The 90th percentile is calculated by default. You can specify other values (from 0 to 100) using the Percentile value parameter.</para>
            /// <para>百分位数—将在间隔内的所有剖面上计算像素值的百分位数。默认情况下计算第 90 个百分位数。您可以使用百分位数值参数指定其他值（从 0 到 100）。</para>
            /// </summary>
            [Description("Percentile")]
            [GPEnumValue("PERCENTILE")]
            _PERCENTILE,

            /// <summary>
            /// <para>Custom</para>
            /// <para>Custom—The pixel value will be calculated based on a custom raster function.</para>
            /// <para>自定义 - 像素值将基于自定义栅格函数进行计算。</para>
            /// </summary>
            [Description("Custom")]
            [GPEnumValue("CUSTOM")]
            _CUSTOM,

        }

        /// <summary>
        /// <para>Variables [Dimension Info] (Description)</para>
        /// <para><xdoc>
        ///   <para>The variable or variables that will be aggregated along the given dimension. If no variable is specified, all variables with the selected dimension will be aggregated.</para>
        ///   <para>For example, to aggregate daily temperature data into monthly average values, specify temperature as the variable to be aggregated. If you do not specify any variables and you have both daily temperature and daily precipitation variables, both variables will be aggregated into monthly averages and the output multidimensional raster will include both variables.</para>
        /// </xdoc></para>
        /// <para><xdoc>
        ///   <para>将沿给定维度聚合的一个或多个变量。如果未指定变量，则将聚合具有所选维度的所有变量。</para>
        ///   <para>例如，要将每日温度数据聚合为月平均值，请将温度指定为要聚合的变量。如果未指定任何变量，并且同时具有日温度变量和日降水变量，则这两个变量都将聚合为月平均值，并且输出多维栅格将同时包含这两个变量。</para>
        /// </xdoc></para>
        /// <para></para>
        /// </summary>
        [DisplayName("Variables [Dimension Info] (Description)")]
        [Description("")]
        [Option(OptionTypeEnum.optional)]
        public List<object> _variables { get; set; } = null;


        /// <summary>
        /// <para>Aggregation Definition</para>
        /// <para><xdoc>
        ///   <para>Specifies the dimension interval for which the data will be aggregated.</para>
        ///   <bulletList>
        ///     <bullet_item>All—The data values will be aggregated across all slices. This is the default.</bullet_item><para/>
        ///     <bullet_item>Interval Keyword—The variable data will be aggregated using a commonly known interval.</bullet_item><para/>
        ///     <bullet_item>Interval Value—The variable data will be aggregated using a user-specified interval and unit.</bullet_item><para/>
        ///     <bullet_item>Interval Ranges—The variable data will be aggregated between specified pairs of values or dates.</bullet_item><para/>
        ///   </bulletList>
        /// </xdoc></para>
        /// <para><xdoc>
        ///   <para>指定将聚合数据的维度间隔。</para>
        ///   <bulletList>
        ///     <bullet_item>全部 - 数据值将聚合到所有切片中。这是默认设置。</bullet_item><para/>
        ///     <bullet_item>区间关键字 - 将使用众所周知的区间聚合变量数据。</bullet_item><para/>
        ///     <bullet_item>间隔值—变量数据将使用用户指定的间隔和单位进行聚合。</bullet_item><para/>
        ///     <bullet_item>间隔范围 - 变量数据将在指定的值或日期对之间聚合。</bullet_item><para/>
        ///   </bulletList>
        /// </xdoc></para>
        /// <para></para>
        /// </summary>
        [DisplayName("Aggregation Definition")]
        [Description("")]
        [Option(OptionTypeEnum.optional)]
        public _aggregation_def_value _aggregation_def { get; set; } = _aggregation_def_value._ALL;

        public enum _aggregation_def_value
        {
            /// <summary>
            /// <para>All</para>
            /// <para>All—The data values will be aggregated across all slices. This is the default.</para>
            /// <para>全部 - 数据值将聚合到所有切片中。这是默认设置。</para>
            /// </summary>
            [Description("All")]
            [GPEnumValue("ALL")]
            _ALL,

            /// <summary>
            /// <para>Interval Keyword</para>
            /// <para>Interval Keyword—The variable data will be aggregated using a commonly known interval.</para>
            /// <para>区间关键字 - 将使用众所周知的区间聚合变量数据。</para>
            /// </summary>
            [Description("Interval Keyword")]
            [GPEnumValue("INTERVAL_KEYWORD")]
            _INTERVAL_KEYWORD,

            /// <summary>
            /// <para>Interval Value</para>
            /// <para>Interval Value—The variable data will be aggregated using a user-specified interval and unit.</para>
            /// <para>间隔值—变量数据将使用用户指定的间隔和单位进行聚合。</para>
            /// </summary>
            [Description("Interval Value")]
            [GPEnumValue("INTERVAL_VALUE")]
            _INTERVAL_VALUE,

            /// <summary>
            /// <para>Interval Ranges</para>
            /// <para>Interval Ranges—The variable data will be aggregated between specified pairs of values or dates.</para>
            /// <para>间隔范围 - 变量数据将在指定的值或日期对之间聚合。</para>
            /// </summary>
            [Description("Interval Ranges")]
            [GPEnumValue("INTERVAL_RANGES")]
            _INTERVAL_RANGES,

        }

        /// <summary>
        /// <para>Keyword Interval</para>
        /// <para><xdoc>
        ///   <para>Specifies the keyword interval that will be used when aggregating along the dimension. This parameter is required when the Aggregation Definition parameter is set to Interval Keyword and the aggregation must be across time.</para>
        ///   <bulletList>
        ///     <bullet_item>Hourly—The data values will be aggregated into hourly time steps, and the result will include every hour in the time series.</bullet_item><para/>
        ///     <bullet_item>Daily—The data values will be aggregated into daily time steps, and the result will include every day in the time series.</bullet_item><para/>
        ///     <bullet_item>Weekly—The data values will be aggregated into weekly time steps, and the result will include every week in the time series.</bullet_item><para/>
        ///     <bullet_item>Dekadly—The data values will be aggregated into 3 periods of 10 days each. The last period can contain more or fewer than 10 days. The output will include 3 slices for each month.</bullet_item><para/>
        ///     <bullet_item>Pentadly—The data values will be aggregated into 6 periods of 5 days each. The last period can contain more or fewer than 5 days. The output will include 6 slices for each month.</bullet_item><para/>
        ///     <bullet_item>Monthly—The data values will be aggregated into monthly time steps, and the result will include every month in the time series.</bullet_item><para/>
        ///     <bullet_item>Quarterly—The data values will be aggregated into quarterly time steps, and the result will include every quarter in the time series.</bullet_item><para/>
        ///     <bullet_item>Yearly—The data values will be aggregated into yearly time steps, and the result will include every year in the time series.</bullet_item><para/>
        ///     <bullet_item>Recurring daily—The data values will be aggregated into daily time steps, and the result will include one aggregated value per Julian day. The output will include, at most, 366 daily time slices.</bullet_item><para/>
        ///     <bullet_item>Recurring weekly—The data values will be aggregated into weekly time steps, and the result will include one aggregated value per week. The output will include, at most, 53 weekly time slices.</bullet_item><para/>
        ///     <bullet_item>Recurring monthly—The data values will be aggregated into monthly time steps, and the result will include one aggregated value per month. The output will include, at most, 12 monthly time slices.</bullet_item><para/>
        ///     <bullet_item>Recurring quarterly—The data values will be aggregated into quarterly time steps, and the result will include one aggregated value per quarter. The output will include, at most, 4 quarterly time slices.</bullet_item><para/>
        ///   </bulletList>
        /// </xdoc></para>
        /// <para><xdoc>
        ///   <para>指定沿维度聚合时将使用的关键字间隔。当“聚合定义”参数设置为“间隔关键字”且聚合必须跨时间时，此参数是必需的。</para>
        ///   <bulletList>
        ///     <bullet_item>每小时—数据值将聚合为每小时时间步长，结果将包括时间序列中的每小时。</bullet_item><para/>
        ///     <bullet_item>每日—数据值将聚合为每日时间步长，结果将包括时间序列中的每一天。</bullet_item><para/>
        ///     <bullet_item>每周—数据值将聚合为每周时间步长，结果将包括时间序列中的每一周。</bullet_item><para/>
        ///     <bullet_item>Dekadly—数据值将聚合为 3 个周期，每个周期 10 天。最后一个周期可以包含多于或少于 10 天。输出将包括每个月的 3 个切片。</bullet_item><para/>
        ///     <bullet_item>Pentadly—数据值将聚合为 6 个周期，每个周期为 5 天。最后一个周期可以包含多于或少于 5 天。输出将包括每个月的 6 个切片。</bullet_item><para/>
        ///     <bullet_item>每月—数据值将聚合为每月时间步长，结果将包括时间序列中的每个月。</bullet_item><para/>
        ///     <bullet_item>季度—数据值将聚合为季度时间步长，结果将包括时间序列中的每个季度。</bullet_item><para/>
        ///     <bullet_item>每年—数据值将聚合为每年的时间步长，结果将包括时间序列中的每一年。</bullet_item><para/>
        ///     <bullet_item>每日重复 - 数据值将聚合为每日时间步长，结果将包括每个儒略日的一个聚合值。输出最多包括 366 个每日时间片。</bullet_item><para/>
        ///     <bullet_item>每周重复一次 - 数据值将聚合为每周时间步长，结果将包括每周一个聚合值。输出最多包括 53 个每周时间片。</bullet_item><para/>
        ///     <bullet_item>每月定期 - 数据值将聚合为每月时间步长，结果将包括每月一个聚合值。输出最多包括 12 个月的时间片。</bullet_item><para/>
        ///     <bullet_item>每季度定期 - 数据值将聚合为每季度的时间步长，结果将包括每季度一个聚合值。输出最多包括 4 个季度时间片。</bullet_item><para/>
        ///   </bulletList>
        /// </xdoc></para>
        /// <para></para>
        /// </summary>
        [DisplayName("Keyword Interval")]
        [Description("")]
        [Option(OptionTypeEnum.optional)]
        public _interval_keyword_value? _interval_keyword { get; set; } = null;

        public enum _interval_keyword_value
        {
            /// <summary>
            /// <para>Hourly</para>
            /// <para>Hourly—The data values will be aggregated into hourly time steps, and the result will include every hour in the time series.</para>
            /// <para>每小时—数据值将聚合为每小时时间步长，结果将包括时间序列中的每小时。</para>
            /// </summary>
            [Description("Hourly")]
            [GPEnumValue("HOURLY")]
            _HOURLY,

            /// <summary>
            /// <para>Daily</para>
            /// <para>Daily—The data values will be aggregated into daily time steps, and the result will include every day in the time series.</para>
            /// <para>每日—数据值将聚合为每日时间步长，结果将包括时间序列中的每一天。</para>
            /// </summary>
            [Description("Daily")]
            [GPEnumValue("DAILY")]
            _DAILY,

            /// <summary>
            /// <para>Weekly</para>
            /// <para>Weekly—The data values will be aggregated into weekly time steps, and the result will include every week in the time series.</para>
            /// <para>每周—数据值将聚合为每周时间步长，结果将包括时间序列中的每一周。</para>
            /// </summary>
            [Description("Weekly")]
            [GPEnumValue("WEEKLY")]
            _WEEKLY,

            /// <summary>
            /// <para>Dekadly</para>
            /// <para>Dekadly—The data values will be aggregated into 3 periods of 10 days each. The last period can contain more or fewer than 10 days. The output will include 3 slices for each month.</para>
            /// <para>Dekadly—数据值将聚合为 3 个周期，每个周期 10 天。最后一个周期可以包含多于或少于 10 天。输出将包括每个月的 3 个切片。</para>
            /// </summary>
            [Description("Dekadly")]
            [GPEnumValue("DEKADLY")]
            _DEKADLY,

            /// <summary>
            /// <para>Pentadly</para>
            /// <para>Pentadly—The data values will be aggregated into 6 periods of 5 days each. The last period can contain more or fewer than 5 days. The output will include 6 slices for each month.</para>
            /// <para>Pentadly—数据值将聚合为 6 个周期，每个周期为 5 天。最后一个周期可以包含多于或少于 5 天。输出将包括每个月的 6 个切片。</para>
            /// </summary>
            [Description("Pentadly")]
            [GPEnumValue("PENTADLY")]
            _PENTADLY,

            /// <summary>
            /// <para>Monthly</para>
            /// <para>Monthly—The data values will be aggregated into monthly time steps, and the result will include every month in the time series.</para>
            /// <para>每月—数据值将聚合为每月时间步长，结果将包括时间序列中的每个月。</para>
            /// </summary>
            [Description("Monthly")]
            [GPEnumValue("MONTHLY")]
            _MONTHLY,

            /// <summary>
            /// <para>Quarterly</para>
            /// <para>Quarterly—The data values will be aggregated into quarterly time steps, and the result will include every quarter in the time series.</para>
            /// <para>季度—数据值将聚合为季度时间步长，结果将包括时间序列中的每个季度。</para>
            /// </summary>
            [Description("Quarterly")]
            [GPEnumValue("QUARTERLY")]
            _QUARTERLY,

            /// <summary>
            /// <para>Yearly</para>
            /// <para>Yearly—The data values will be aggregated into yearly time steps, and the result will include every year in the time series.</para>
            /// <para>每年—数据值将聚合为每年的时间步长，结果将包括时间序列中的每一年。</para>
            /// </summary>
            [Description("Yearly")]
            [GPEnumValue("YEARLY")]
            _YEARLY,

            /// <summary>
            /// <para>Recurring daily</para>
            /// <para>Recurring daily—The data values will be aggregated into daily time steps, and the result will include one aggregated value per Julian day. The output will include, at most, 366 daily time slices.</para>
            /// <para>每日重复 - 数据值将聚合为每日时间步长，结果将包括每个儒略日的一个聚合值。输出最多包括 366 个每日时间片。</para>
            /// </summary>
            [Description("Recurring daily")]
            [GPEnumValue("RECURRING_DAILY")]
            _RECURRING_DAILY,

            /// <summary>
            /// <para>Recurring weekly</para>
            /// <para>Recurring weekly—The data values will be aggregated into weekly time steps, and the result will include one aggregated value per week. The output will include, at most, 53 weekly time slices.</para>
            /// <para>每周重复一次 - 数据值将聚合为每周时间步长，结果将包括每周一个聚合值。输出最多包括 53 个每周时间片。</para>
            /// </summary>
            [Description("Recurring weekly")]
            [GPEnumValue("RECURRING_WEEKLY")]
            _RECURRING_WEEKLY,

            /// <summary>
            /// <para>Recurring monthly</para>
            /// <para>Recurring monthly—The data values will be aggregated into monthly time steps, and the result will include one aggregated value per month. The output will include, at most, 12 monthly time slices.</para>
            /// <para>每月定期 - 数据值将聚合为每月时间步长，结果将包括每月一个聚合值。输出最多包括 12 个月的时间片。</para>
            /// </summary>
            [Description("Recurring monthly")]
            [GPEnumValue("RECURRING_MONTHLY")]
            _RECURRING_MONTHLY,

            /// <summary>
            /// <para>Recurring quarterly</para>
            /// <para>Recurring quarterly—The data values will be aggregated into quarterly time steps, and the result will include one aggregated value per quarter. The output will include, at most, 4 quarterly time slices.</para>
            /// <para>每季度定期 - 数据值将聚合为每季度的时间步长，结果将包括每季度一个聚合值。输出最多包括 4 个季度时间片。</para>
            /// </summary>
            [Description("Recurring quarterly")]
            [GPEnumValue("RECURRING_QUARTERLY")]
            _RECURRING_QUARTERLY,

        }

        /// <summary>
        /// <para>Value Interval</para>
        /// <para><xdoc>
        ///   <para>The size of the interval that will be used for the aggregation. This parameter is required when the Aggregation Definition parameter is set to Interval Value.</para>
        ///   <para>For example, to aggregate 30 years of monthly temperature data into 5-year increments, enter 5 as the Value Interval, and specify Unit as Years.</para>
        /// </xdoc></para>
        /// <para><xdoc>
        ///   <para>将用于聚合的间隔的大小。当“聚合定义”参数设置为“间隔值”时，此参数是必需的。</para>
        ///   <para>例如，要将 30 年的月度温度数据聚合为 5 年的增量，请输入 5 作为值区间，并将“单位”指定为“年”。</para>
        /// </xdoc></para>
        /// <para></para>
        /// </summary>
        [DisplayName("Value Interval")]
        [Description("")]
        [Option(OptionTypeEnum.optional)]
        public double? _interval_value { get; set; } = null;


        /// <summary>
        /// <para>Unit</para>
        /// <para><xdoc>
        ///   <para>The unit that will be used for the Value Interval parameter. This parameter is required when the Dimension parameter is a time field and the Aggregation Definition parameter is set to Interval Value.</para>
        ///   <para>If you are aggregating anything other than time, this option will not be available and the unit for the interval value will match the variable unit of the input multidimensional raster data.</para>
        ///   <bulletList>
        ///     <bullet_item>Hours—The data values will be aggregated into hourly time slices at the interval provided.</bullet_item><para/>
        ///     <bullet_item>Days—The data values will be aggregated into daily time slices at the interval provided.</bullet_item><para/>
        ///     <bullet_item>Weeks—The data values will be aggregated into weekly time slices at the interval provided.</bullet_item><para/>
        ///     <bullet_item>Months—The data values will be aggregated into monthly time slices at the interval provided.</bullet_item><para/>
        ///     <bullet_item>Years—The data values will be aggregated into yearly time slices at the interval provided.</bullet_item><para/>
        ///   </bulletList>
        /// </xdoc></para>
        /// <para><xdoc>
        ///   <para>将用于“值间隔”参数的单位。当 Dimension 参数为时间字段且 Aggregation Definition 参数设置为 Interval Value 时，此参数是必需的。</para>
        ///   <para>如果要聚合时间以外的任何内容，则此选项将不可用，并且间隔值的单位将与输入多维栅格数据的可变单位匹配。</para>
        ///   <bulletList>
        ///     <bullet_item>小时—数据值将按提供的时间间隔聚合到每小时时间片中。</bullet_item><para/>
        ///     <bullet_item>天 - 数据值将按提供的时间间隔聚合到每日时间片中。</bullet_item><para/>
        ///     <bullet_item>周 - 数据值将按提供的时间间隔聚合到每周时间片中。</bullet_item><para/>
        ///     <bullet_item>月—数据值将按提供的时间间隔聚合到每月时间片中。</bullet_item><para/>
        ///     <bullet_item>年—数据值将按规定的时间间隔聚合到年度时间片中。</bullet_item><para/>
        ///   </bulletList>
        /// </xdoc></para>
        /// <para></para>
        /// </summary>
        [DisplayName("Unit")]
        [Description("")]
        [Option(OptionTypeEnum.optional)]
        public _interval_unit_value? _interval_unit { get; set; } = null;

        public enum _interval_unit_value
        {
            /// <summary>
            /// <para>Hours</para>
            /// <para>Hours—The data values will be aggregated into hourly time slices at the interval provided.</para>
            /// <para>小时—数据值将按提供的时间间隔聚合到每小时时间片中。</para>
            /// </summary>
            [Description("Hours")]
            [GPEnumValue("HOURS")]
            _HOURS,

            /// <summary>
            /// <para>Days</para>
            /// <para>Days—The data values will be aggregated into daily time slices at the interval provided.</para>
            /// <para>天 - 数据值将按提供的时间间隔聚合到每日时间片中。</para>
            /// </summary>
            [Description("Days")]
            [GPEnumValue("DAYS")]
            _DAYS,

            /// <summary>
            /// <para>Weeks</para>
            /// <para>Weeks—The data values will be aggregated into weekly time slices at the interval provided.</para>
            /// <para>周 - 数据值将按提供的时间间隔聚合到每周时间片中。</para>
            /// </summary>
            [Description("Weeks")]
            [GPEnumValue("WEEKS")]
            _WEEKS,

            /// <summary>
            /// <para>Months</para>
            /// <para>Months—The data values will be aggregated into monthly time slices at the interval provided.</para>
            /// <para>月—数据值将按提供的时间间隔聚合到每月时间片中。</para>
            /// </summary>
            [Description("Months")]
            [GPEnumValue("MONTHS")]
            _MONTHS,

            /// <summary>
            /// <para>Years</para>
            /// <para>Years—The data values will be aggregated into yearly time slices at the interval provided.</para>
            /// <para>年—数据值将按规定的时间间隔聚合到年度时间片中。</para>
            /// </summary>
            [Description("Years")]
            [GPEnumValue("YEARS")]
            _YEARS,

        }

        /// <summary>
        /// <para>Range</para>
        /// <para><xdoc>
        ///   <para>Interval ranges specified in a value table will be used to aggregate groups of values. The value table consists of pairs of minimum and maximum range values, with data type Double or Date.</para>
        ///   <para>This parameter is required when the Aggregation Definition parameter is set to Interval Ranges.</para>
        /// </xdoc></para>
        /// <para><xdoc>
        ///   <para>值表中指定的间隔范围将用于聚合值组。值表由最小值和最大范围值对组成，数据类型为 Double 或 Date。</para>
        ///   <para>当“聚合定义”参数设置为“区间范围”时，此参数是必需的。</para>
        /// </xdoc></para>
        /// <para></para>
        /// </summary>
        [DisplayName("Range")]
        [Description("")]
        [Option(OptionTypeEnum.optional)]
        public object _interval_ranges { get; set; } = null;


        /// <summary>
        /// <para>Aggregation Function</para>
        /// <para><xdoc>
        ///   <para>A custom raster function that will be used to compute the pixel values of the aggregated rasters. The input is a raster function JSON object or an .rft.xml file created from a function chain or a custom Python raster function.</para>
        ///   <para>This parameter is required when the Aggregation Method parameter is set to Custom.</para>
        /// </xdoc></para>
        /// <para><xdoc>
        ///   <para>将用于计算聚合栅格的像素值的自定义栅格函数。输入是栅格函数 JSON 对象或从函数链或自定义 Python 栅格函数创建的.rft.xml文件。</para>
        ///   <para>当“聚合方法”参数设置为“自定义”时，此参数是必需的。</para>
        /// </xdoc></para>
        /// <para></para>
        /// </summary>
        [DisplayName("Aggregation Function")]
        [Description("")]
        [Option(OptionTypeEnum.optional)]
        public object _aggregation_function { get; set; } = null;


        /// <summary>
        /// <para>Ignore NoData</para>
        /// <para><xdoc>
        ///   <para>Specifies whether NoData values are ignored in the analysis.</para>
        ///   <bulletList>
        ///     <bullet_item>Checked—The analysis will include all valid pixels along a given dimension and ignore any NoData pixels. This is the default.</bullet_item><para/>
        ///     <bullet_item>Unchecked—The analysis will result in NoData if there are any NoData values for the pixels along the given dimension.</bullet_item><para/>
        ///   </bulletList>
        /// </xdoc></para>
        /// <para><xdoc>
        ///   <para>指定是否在分析中忽略 NoData 值。</para>
        ///   <bulletList>
        ///     <bullet_item>选中 - 分析将包括给定维度上的所有有效像素，并忽略任何 NoData 像素。这是默认设置。</bullet_item><para/>
        ///     <bullet_item>未选中 - 如果给定维度上的像素有任何 NoData 值，则分析将生成 NoData。</bullet_item><para/>
        ///   </bulletList>
        /// </xdoc></para>
        /// <para></para>
        /// </summary>
        [DisplayName("Ignore NoData")]
        [Description("")]
        [Option(OptionTypeEnum.optional)]
        public _ignore_nodata_value _ignore_nodata { get; set; } = _ignore_nodata_value._true;

        public enum _ignore_nodata_value
        {
            /// <summary>
            /// <para>DATA</para>
            /// <para></para>
            /// <para></para>
            /// </summary>
            [Description("DATA")]
            [GPEnumValue("true")]
            _true,

            /// <summary>
            /// <para>NODATA</para>
            /// <para></para>
            /// <para></para>
            /// </summary>
            [Description("NODATA")]
            [GPEnumValue("false")]
            _false,

        }

        /// <summary>
        /// <para>Dimensionless</para>
        /// <para><xdoc>
        ///   <para>Specifies whether the layer will have dimension values. This parameter is only active if a single slice is selected to create a layer.
        ///   <bulletList>
        ///     <bullet_item>Checked—The layer will not have dimension values.  </bullet_item><para/>
        ///     <bullet_item>Unchecked—The layer will have dimension values. This is the default.  </bullet_item><para/>
        ///   </bulletList>
        ///   </para>
        /// </xdoc></para>
        /// <para><xdoc>
        /// <para>指定图层是否具有维度值。仅当选择单个切片创建图层时，此参数才处于活动状态。
        ///   <bulletList>
        ///     <bullet_item>选中 - 图层将不具有尺寸值。</bullet_item><para/>
        ///     <bullet_item>未选中 - 图层将具有尺寸值。这是默认设置。 </bullet_item><para/>
        ///   </bulletList>
        ///   </para>
        /// </xdoc></para>
        /// <para></para>
        /// </summary>
        [DisplayName("Dimensionless")]
        [Description("")]
        [Option(OptionTypeEnum.optional)]
        public _dimensionless_value _dimensionless { get; set; } = _dimensionless_value._false;

        public enum _dimensionless_value
        {
            /// <summary>
            /// <para>NO_DIMENSIONS</para>
            /// <para></para>
            /// <para></para>
            /// </summary>
            [Description("NO_DIMENSIONS")]
            [GPEnumValue("true")]
            _true,

            /// <summary>
            /// <para>DIMENSIONS</para>
            /// <para></para>
            /// <para></para>
            /// </summary>
            [Description("DIMENSIONS")]
            [GPEnumValue("false")]
            _false,

        }

        /// <summary>
        /// <para>Percentile value</para>
        /// <para><xdoc>
        ///   <para>The percentile to calculate. The default is 90, indicating the 90th percentile.</para>
        ///   <para>The values can range from 0 to 100. The 0th percentile is essentially equivalent to the minimum statistic, and the 100th percentile is equivalent to maximum. A value of 50 will produce essentially the same result as the median statistic.</para>
        ///   <para>This option is only available if the Statistics type parameter is set to Percentile.</para>
        /// </xdoc></para>
        /// <para><xdoc>
        ///   <para>要计算的百分位数。默认值为 90，表示第 90 个百分位数。</para>
        ///   <para>这些值的范围可以从 0 到 100。第 0 个百分位数基本等于最小统计量，第 100 个百分位数等于最大值。值为 50 将产生与中位数统计量基本相同的结果。</para>
        ///   <para>仅当统计信息类型参数设置为百分位数时，此选项才可用。</para>
        /// </xdoc></para>
        /// <para></para>
        /// </summary>
        [DisplayName("Percentile value")]
        [Description("")]
        [Option(OptionTypeEnum.optional)]
        public double _percentile_value { get; set; } = 90;


        /// <summary>
        /// <para>Percentile interpolation type</para>
        /// <para><xdoc>
        ///   <para>Specifies the method of percentile interpolation that will be used when there is an even number of values from the input raster to be calculated.</para>
        ///   <bulletList>
        ///     <bullet_item>Nearest—The nearest available value to the desired percentile will be used. In this case, the output pixel type will be the same as that of the input value raster.</bullet_item><para/>
        ///     <bullet_item>Linear—The weighted average of the two surrounding values from the desired percentile will be used. In this case, the output pixel type will be floating point.</bullet_item><para/>
        ///   </bulletList>
        /// </xdoc></para>
        /// <para><xdoc>
        ///   <para>指定当要计算输入栅格中的偶数个值时将使用的百分位插值方法。</para>
        ///   <bulletList>
        ///     <bullet_item>最近—将使用最接近所需百分位数的可用值。在这种情况下，输出像素类型将与输入值栅格的输出像素类型相同。</bullet_item><para/>
        ///     <bullet_item>线性—将使用所需百分位数中两个周围值的加权平均值。在这种情况下，输出像素类型将为浮点数。</bullet_item><para/>
        ///   </bulletList>
        /// </xdoc></para>
        /// <para></para>
        /// </summary>
        [DisplayName("Percentile interpolation type")]
        [Description("")]
        [Option(OptionTypeEnum.optional)]
        public _percentile_interpolation_type_value _percentile_interpolation_type { get; set; } = _percentile_interpolation_type_value._NEAREST;

        public enum _percentile_interpolation_type_value
        {
            /// <summary>
            /// <para>Nearest</para>
            /// <para>Nearest—The nearest available value to the desired percentile will be used. In this case, the output pixel type will be the same as that of the input value raster.</para>
            /// <para>最近—将使用最接近所需百分位数的可用值。在这种情况下，输出像素类型将与输入值栅格的输出像素类型相同。</para>
            /// </summary>
            [Description("Nearest")]
            [GPEnumValue("NEAREST")]
            _NEAREST,

            /// <summary>
            /// <para>Linear</para>
            /// <para>Linear—The weighted average of the two surrounding values from the desired percentile will be used. In this case, the output pixel type will be floating point.</para>
            /// <para>线性—将使用所需百分位数中两个周围值的加权平均值。在这种情况下，输出像素类型将为浮点数。</para>
            /// </summary>
            [Description("Linear")]
            [GPEnumValue("LINEAR")]
            _LINEAR,

        }

        public AggregateMultidimensionalRaster SetEnv(object cellSize = null, object compression = null, object configKeyword = null, object extent = null, object geographicTransformations = null, object nodata = null, object outputCoordinateSystem = null, object parallelProcessingFactor = null, object pyramid = null, object rasterStatistics = null, object resamplingMethod = null, object scratchWorkspace = null, object snapRaster = null, double[] tileSize = null, object workspace = null)
        {
            base.SetEnv(cellSize: cellSize, compression: compression, configKeyword: configKeyword, extent: extent, geographicTransformations: geographicTransformations, nodata: nodata, outputCoordinateSystem: outputCoordinateSystem, parallelProcessingFactor: parallelProcessingFactor, pyramid: pyramid, rasterStatistics: rasterStatistics, resamplingMethod: resamplingMethod, scratchWorkspace: scratchWorkspace, snapRaster: snapRaster, tileSize: tileSize, workspace: workspace);
            return this;
        }

    }

}